﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using System.Data;
using System.IO;
using StuertzDatenbank;
using WW.Cad.Model;
using WW.Cad.IO;
using WW.Cad;
using System.Windows.Forms;
using StuertzDatenbank.Properties;
using System.Net.NetworkInformation;




namespace StuertzDatenbank
{
    public class DBF
    {

        string connString = Settings.Default.DBVerbindung;
      
        protected void addAnsprechpartnerSprache(int ID, int Sprache)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addAnsprechpartnerSprache";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Sprache", Sprache);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        public void addAuftragTeil(Teil T, Auftrag A)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addAuftragTeil";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@AuftragID", A.getAuftragsnummer());
            command.Parameters.AddWithValue("@TeilID", T.getID());
            command.Parameters.AddWithValue("@Kundenbezeichnung", T.getKundenbezeichnung());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addHerstellerAnsprechpartner(int ID, int AnsprechparterID)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addHerstellerAnsprechpartner";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@HerstellerID", ID);
            command.Parameters.AddWithValue("@AnsprechpartnerID", AnsprechparterID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addKundeAnsprechpartner(int KundeID, int AnsprechpartnerID)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addKundeAnsprechpartner";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@KundeID", KundeID);
            command.Parameters.AddWithValue("@AnsprechpartnerID", AnsprechpartnerID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addKundeSerie(int ID, int SerieID)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addKundeSerie";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Serie", SerieID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addProfilBearbeitung(int ID, int Bearbeitung)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addProfilBearbeitung";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Bearbeitung", Bearbeitung);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addProfilBeschichtung(int ID, int Beschichtung)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addProfilBeschichtung";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Beschichtung", Beschichtung);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addProfilDichtung(int ID, int Dichtung)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addProfilDichtung";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Dichtung", Dichtung);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addProfilEinbaulage(int ID, int Lage)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addProfilEinbaulage";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Einbaulage", Lage);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addProfilFuellmaterial(int ID, int Material)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addProfilFuellmaterial";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Material", Material);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addProfilRestriktion(int ID, int Restriktion)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addProfilRestriktion";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Restriktion", Restriktion);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        public void addProfilnewRestriktion(Profil P, Restriktion R)
        {

            R.setID(createRestriktion(R));
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addProfilRestriktion";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", P.getID());
            command.Parameters.AddWithValue("@Restriktion", R.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addProfilSerie(int ID, int Serie)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addProfilSerie";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Serie", Serie);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addProfilWerkstoff(int ID, int Werkstoff)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addProfilWerkstoff";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Werkstoff", Werkstoff);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addProfilHersteller(int ID, int Hersteller)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addProfilHersteller";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Profil", ID);
            command.Parameters.AddWithValue("@Hersteller", Hersteller);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addTeilBearbeitung(int ID, int Bearbeitung)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addTeilBearbeitung";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Bearbeitung", Bearbeitung);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addTeilBeschichtung(int ID, int Beschichtung)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addTeilBeschichtung";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Beschichtung", Beschichtung);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addTeilDichtung(int ID, int Dichtung)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addTeilDichtung";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Dichtung", Dichtung);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addTeilEinbaulage(int ID, int Einbaulage)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addTeilEinbaulage";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Einbaulage", Einbaulage);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addTeilFuellmaterial(int ID, int Fuellmaterial)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addTeilFuellmaterial";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Fuellmaterial", Fuellmaterial);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addTeilRestriktion(int ID, int Restriktion)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addTeilRestriktion";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Restriktion", Restriktion);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void addTeilWerkstoff(int ID, int Werkstoff)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "addTeilWerkstoff";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Werkstoff", Werkstoff);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected int createAnsprechpartner(int Geschlecht, string VName, string NName, string Titel, string Fachbereich, string Telefon1, string Telefon2, string Mail, string Fax, string Kommentar)
        {
            int ID = new int();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createAnsprechpartner";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Geschlecht", Geschlecht);
            command.Parameters.AddWithValue("@Vorname", VName);
            command.Parameters.AddWithValue("@Nachname", NName);
            command.Parameters.AddWithValue("@Titel", Titel);
            command.Parameters.AddWithValue("@Fachbereich", Fachbereich);
            command.Parameters.AddWithValue("@Telefon1", Telefon1);
            command.Parameters.AddWithValue("@Telefon2", Telefon2);
            command.Parameters.AddWithValue("@Email", Mail);
            command.Parameters.AddWithValue("@Fax", Fax);
            command.Parameters.AddWithValue("@Kommentar", Kommentar);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                ID = reader.GetInt32(0);
            }
            conn.Close();
            return ID;
        }

        protected int createBearbeitung(Bearbeitungen B)
        {
            MemoryStream mstream = new MemoryStream();
            DxfWriter.Write(mstream, B.getLayer());
            byte[] Data = mstream.ToArray();
            mstream.Flush();
            mstream.Close();
            int ID = new int();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createBearbeitung";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Nummer", B.getBearbeitungsnummer());
            command.Parameters.AddWithValue("@Name", B.getBearbeitungsname());
            command.Parameters.AddWithValue("@WerkzeugID", B.getWerkzeug().getID());
            command.Parameters.AddWithValue("@Winkel", B.getBearbeitungswinkel());
            command.Parameters.AddWithValue("@Kommentar", B.getKommentar());
            command.Parameters.AddWithValue("@Layer", Data);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                ID = reader.GetInt32(0);
            }
            conn.Close();
            return ID;
        }

        protected void createBenutzer(int ID, string Name, int RolleID)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createBenutzer";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Name", Name);
            command.Parameters.AddWithValue("@RolleID", RolleID);
           
            try
            {
                conn.Open();
                SqlDataReader reader = command.ExecuteReader();
                conn.Close();
            }
            catch (Exception e)
            {
                MessageBox.Show(e.ToString());

            }
          
        }

        public int createBeschichtung(Beschichtungen B)
        {
            int i = new int();
            i = -1;
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createBeschichtung";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Beschichtung", B.getBeschichtungen());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
	            {
                    i = reader.GetInt32(0);
	            }
            conn.Close();
            return i;
        }

        protected void createCountry(string Country)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createCountry";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Name", Country);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected int createDichtung(Dichtung D)
        {
            MemoryStream mstream = new MemoryStream();
            DxfWriter.Write(mstream, D.getDichtungslayer());
            byte[] Data = mstream.ToArray();
            mstream.Flush();
            mstream.Close();
            int ID = new int();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createDichtung";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Dichtung", D.getDichtung());
            command.Parameters.AddWithValue("@DichtungLayer", Data);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                ID = reader.GetInt32(0);
            }
            conn.Close();
            return ID;
        }

        public void createEinbaulage(VerwendungPosition VPos)
        {

            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createEinbaulage";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Einbaulage", VPos.getVerwendungPosition());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();

        }

        protected int createFuellmaterial(Fuellmaterial F)
        {
            MemoryStream mstream = new MemoryStream();
            DxfWriter.Write(mstream, F.getLayer());
            byte[] Data = mstream.ToArray();
            mstream.Flush();
            mstream.Close();
            int ID = new int();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createFuellmaterial";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Fuellmaterial", F.getFuellmaterial());
            command.Parameters.AddWithValue("@Layer", Data);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                ID = reader.GetInt32(0);
            }
            conn.Close();
            return ID;
        }

        protected void createHersteller(int ID, string Name, string Addline1, string Addline2, string Stadt, string Staat, string PLZ, int Land)
        {

            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createHersteller";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Name", Name);
            command.Parameters.AddWithValue("@Addline1", Addline1);
            command.Parameters.AddWithValue("@Addline2", Addline2);
            command.Parameters.AddWithValue("@Stadt", Stadt);
            command.Parameters.AddWithValue("@Staat", Staat);
            command.Parameters.AddWithValue("@PLZ", PLZ);
            command.Parameters.AddWithValue("@Land", Land);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void changeHersteller(int ID, string Name, string Addline1, string Addline2, string Stadt, string Staat, string PLZ, int Land)
        {

            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "changeHersteller";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            command.Parameters.AddWithValue("@Name", Name);
            command.Parameters.AddWithValue("@Addline1", Addline1);
            command.Parameters.AddWithValue("@Addline2", Addline2);
            command.Parameters.AddWithValue("@Stadt", Stadt);
            command.Parameters.AddWithValue("@Staat", Staat);
            command.Parameters.AddWithValue("@PLZ", PLZ);
            command.Parameters.AddWithValue("@Land", Land);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void changeProfil(Profil P)
        {
            MemoryStream mstream = new MemoryStream();
            DxfWriter.Write(mstream, P.getZeichnung());
            byte[] Data = mstream.ToArray();
            mstream.Flush();
            mstream.Close();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "changeProfil";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", P.getID());
            command.Parameters.AddWithValue("@Bezeichnung", P.getBezeichnung());
            command.Parameters.AddWithValue("@Hoehe", P.getHoeheAbs());
            command.Parameters.AddWithValue("@Tiefe", P.getTiefeAbs());
            command.Parameters.AddWithValue("@Typ", booltoint(P.getRahmenFenster()));
            command.Parameters.AddWithValue("@FreigabeVon", P.getFreigabeVon().getMitarbeiternummer());
            command.Parameters.AddWithValue("@FreigabeWann", P.getFreigabeWann());
            command.Parameters.AddWithValue("@Kommentar", P.getKommentar());
            command.Parameters.AddWithValue("@Zeichnung", Data);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected int createProfil(string Bezeichnung, decimal Hoehe, decimal Tiefe, int Typ, int ErstelltVon, DateTime ErstelltWann, int FreigabeVon, DateTime FreigabeWann, string Kommentar, DxfModel Layer)
        {
            MemoryStream mstream = new MemoryStream();
            DxfWriter.Write(mstream, Layer);
            byte[] Data = mstream.ToArray();
            mstream.Flush();
            mstream.Close();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createProfil";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Bezeichnung", Bezeichnung);
            command.Parameters.AddWithValue("@Hoehe", Hoehe);
            command.Parameters.AddWithValue("@Tiefe", Tiefe);
            command.Parameters.AddWithValue("@Typ", Typ);
            command.Parameters.AddWithValue("@ErstelltVon", ErstelltVon);
            command.Parameters.AddWithValue("@ErstelltWann", ErstelltWann);
            command.Parameters.AddWithValue("@FreigabeVon", FreigabeVon);
            command.Parameters.AddWithValue("@FreigabeWann", FreigabeWann);
            command.Parameters.AddWithValue("@Kommentar", Kommentar);
            command.Parameters.AddWithValue("@Zeichnung", Data);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            int ID = new int();
            while (reader.Read())
            {
                ID = reader.GetInt32(0);
            }
            conn.Close();
            return ID;
        }

        protected int createRestriktion(Restriktion R)
        {
            int ID = new int();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createRestriktion";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Artikelnummer", R.getArtikelnummer());
            command.Parameters.AddWithValue("@Bezeichnung", R.getRestriktion());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                ID = reader.GetInt32(0);
            }
            conn.Close();
            return ID;
        }

        protected int createRolle(string Rolle, string Passwort, string Rechte)
        {
            int ID = new int();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createRolle";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Rolle", Rolle);
            command.Parameters.AddWithValue("@PW", Passwort);
            command.Parameters.AddWithValue("@Rechte", Rechte);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                ID = reader.GetInt32(0);
            }
            conn.Close();
            return ID;
        }

        public int createSerie(Serie Serie)
        {
            int ID = new int();
            bool b = new bool();
            b = false;
            List<Serie> Liste = new List<Serie>(listHerstellerSerien());
            while (Liste.Count() != 0)
            {
                b = Serie.getSerie() == Liste.First().getSerie();
                if (b)
                {
                    Liste.Clear();
                }
                else
                {
                    Liste.RemoveAt(0);
                }
            }
            if (!b)
	        {
	            SqlConnection conn = new SqlConnection(connString);
                SqlCommand command = conn.CreateCommand();
                command.CommandText = "createSerie";
                command.CommandType = System.Data.CommandType.StoredProcedure;
                command.Parameters.AddWithValue("@Name", Serie.getSerie());
                conn.Open();
                SqlDataReader reader = command.ExecuteReader();
                while (reader.Read())
                {
                    ID = reader.GetInt32(0);
                }
                conn.Close();
	        }
            return ID;
        }

        public Serie createKundenserie(Serie S, Kunde K)
        {
            int ID = new int();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createKundenserie";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Serie", S.getSerie());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                ID = reader.GetInt32(0);
            }
            conn.Close();
            S.setID(ID);
            addKundeSerie(K.getKundennummer(), S.getID());
            return S;
        }

        protected int createSprache(string Sprache)
        {
            int ID = new int();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createSprache";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Sprache", Sprache);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                ID = reader.GetInt32(0);
            }
            conn.Close();
            return ID;
        }

        protected int createTeil(int ProfilID, string kommentar, int ev, DateTime ew, int fv, DateTime fw, int status, int serie)
        {
            int ID = new int();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createTeil";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ProfilID", ProfilID);
            command.Parameters.AddWithValue("@Kommentar", kommentar);
            command.Parameters.AddWithValue("@EV", ev);
            command.Parameters.AddWithValue("@EW", ew);
            command.Parameters.AddWithValue("@FV", fv);
            command.Parameters.AddWithValue("@FW", fw);
            command.Parameters.AddWithValue("@Status", status);
            command.Parameters.AddWithValue("@Serie", serie);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                ID = reader.GetInt32(0);
            }
            conn.Close();
            return ID;
        }

        public void createWerkstoff(Werkstoff W)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createWerkstoff";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Werkstoff", W.getWerkstoff());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        public void createWerkzeug(Werkzeug Werkzeug)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "createWerkzeug";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Art", Werkzeug.getWerkzeugart());
            command.Parameters.AddWithValue("@Maße", Werkzeug.getWerkzeugmaße());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void deleteDichtung(Dichtung D)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "deleteDichtung";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", D.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void deleteBearbeitung(Bearbeitungen B)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "deleteBearbeitung";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", B.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void deleteRestriktion(Restriktion R)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "deleteRestriktion";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", R.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void deleteSerie(Serie S)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "deleteSerie";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", S.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void deleteKundenserie(Serie S)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "deleteKundenserie";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", S.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        protected void deleteFuellmaterial(Fuellmaterial F)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "deleteFuellmaterial";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", F.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        public List<Werkstoff> getAllWerstoffe()
        {
            List<Werkstoff> Liste = new List<Werkstoff>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAllProfilMaterials";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while(reader.Read())
            {
                Werkstoff W = new Werkstoff(reader.GetInt32(0));
                W.setWerkstoff(reader.GetString(1));
                Liste.Add(W);
            }
            conn.Close();
            return Liste;
        }

        public List<Werkzeug> getAllWerkzeuge()
        {
            List<Werkzeug> Liste = new List<Werkzeug>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAllWerkzeuge";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Werkzeug W = new Werkzeug();
                W.setID(reader.GetInt32(0));
                W.setWerkzeugart(reader.GetString(1));
                W.setWerkzeugmaße(reader.GetString(2));
                Liste.Add(W);
            }
            conn.Close();
            return Liste;
        }

        public List<Profil> getAllProfile()
        {
            List<Profil> Liste = new List<Profil>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAllProfile";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                /*byte[] Layer = null;
                Layer = (byte[])reader[11];
                MemoryStream mstream = new MemoryStream();
                mstream.Write(Layer, 0, Layer.Length);
                DxfReader dxfread = new DxfReader(mstream);
                DxfModel Data = dxfread.Read();
                mstream.Flush();
                mstream.Close();*/
                Profil P = new Profil(-1);
                P.setID(reader.GetInt32(0));
                P.setBezeichnung(reader.GetString(1));
               /* P.setHoeheAbs(reader.GetInt32(2));
                P.setTiefeAbs(reader.GetInt32(3));
                P.setRahmenFenster(inttobool(reader.GetInt32(4)));
                P.setErstelltVon(getBenutzerByID(reader.GetInt32(5)));g
                P.setErstelltWann(reader.GetDateTime(6));
                P.setFreigabeVon(getBenutzerByID(reader.GetInt32(7)));
                P.setFreigabeWann(reader.GetDateTime(8));
                P.setKommentar(reader.GetString(9));
                P.setStatus(getStatusByID(reader.GetInt32(10)));
                P.setZeichnung(Data);*/
                Liste.Add(P);
            }
            conn.Close();
            return Liste;
        }

        public List<Status> getAllStatus()
        {
            List<Status> Liste = new List<Status>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAllStatuses";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Status Status = new Status(-1);
                Status.setID(reader.GetInt32(0));
                Status.setStatus(reader.GetString(1));
                Liste.Add(Status);
            }
            conn.Close();
            return Liste;
        }
        /// <summary>
        /// Gibt NUR alle KundenIds und Kundennamen aus.
        /// </summary>
        /// <returns></returns>
        public List<Kunde> alleKundenAusgeben()
        {
            List<Kunde> Liste = new List<Kunde>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAllKundenIDs";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Kunde Kunde = new Kunde(-1);
                Kunde.setKundennummer(reader.GetInt32(0));
                Kunde.setName(reader.GetString(1));
                Liste.Add(Kunde);
                
            }
            conn.Close();
            return Liste;
        }

        public List<VerwendungPosition> getAllEinbaulagen()
        {
            List<VerwendungPosition> Liste = new List<VerwendungPosition>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAlleEinbaulagen";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                VerwendungPosition V = new VerwendungPosition(-1);
                V.setID(reader.GetInt32(0));
                V.setVerwendungPosition(reader.GetString(1));
                Liste.Add(V);
            }
            conn.Close();
            return Liste;
        }

        protected Geschlecht getGeschlechtByID(int ID)
        {
            Geschlecht Sex = new Geschlecht();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getGeschlechtByID";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Sex.setID(ID);
                Sex.setGeschlecht(reader.GetString(0));
            }
            conn.Close();
            return Sex;
        }

        protected Rolle getRolle(int ID)
        {
            Rolle Rolle = new Rolle();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getRolle";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Rolle.setid(reader.GetInt32(0));
                Rolle.setRollenbezeichnung(reader.GetSqlString(1).ToString());
                Rolle.setPasswort(reader.GetSqlString(2).ToString());
                Rechte Rechte = new Rechte();
                Rechte.setRechteString(reader.GetSqlString(3).ToString());
                Rolle.setRechte(Rechte);
            }
            conn.Close();
            return Rolle;
        }

        public List<Profil> getProfileBySerie(Serie Serie)
        {
            List<Profil> Liste = new List<Profil>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getProfileBySerie";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", Serie.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Profil A = new Profil(-1);
                A.setID(reader.GetInt32(0));
                A.setBezeichnung(reader.GetString(1));
                Liste.Add(A);
            }
            conn.Close();
            return Liste;
        }

        public List<Profil> getProfileBySerieOhneAusgecheckte(Serie Serie)
        {
            List<Profil> Liste = new List<Profil>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getProfileBySerieOhneAusgecheckte";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", Serie.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Profil A = new Profil(-1);
                A.setID(reader.GetInt32(0));
                A.setBezeichnung(reader.GetString(1));
                Liste.Add(A);
            }
            conn.Close();
            return Liste;
        }

        public List<Profil> getProfilesByName(string Part)
        {
            List<Profil> Liste = new List<Profil>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getProfilByPartName";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Name", Part);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Profil P = new Profil(reader.GetInt32(0));
                P.setBezeichnung(reader.GetString(1));
                Liste.Add(P);
            }
            conn.Close();
            return Liste;
        }

        public List<Profil> getProfileByHersteller(Hersteller H)
        {
            List<Profil> Liste = new List<Profil>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getProfilesFromHersteller";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", H.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Profil P = new Profil(reader.GetInt32(0));
                P.setBezeichnung(reader.GetString(1));
                Liste.Add(P);
            }
            conn.Close();
            return Liste;
        }

        protected Serie getKundenserie(int ID)
        {
            Serie Serie = new Serie(ID);
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getKundenserieByID";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Serie.setSerie(reader.GetString(0));
            }
            conn.Close();
            return Serie;
        }

        public List<Serie> getKundenserien(Kunde K)
        {
            List<Serie> Liste = new List<Serie>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getKundenserieByKunde";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", K.getKundennummer());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Serie Serie = new Serie(reader.GetInt32(0));
                Serie.setSerie(reader.GetString(1));
                Liste.Add(Serie);
            }
            conn.Close();
            return Liste;
        }

        public List<Serie> getHerstellerserien(Hersteller Hersteller)
        {
            List<Serie> Liste = new List<Serie>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getSerieFromHersteller";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", Hersteller.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Serie Serie = new Serie(-1);
                Serie.setID(reader.GetInt32(0));
                Serie.setSerie(reader.GetString(1));
                if (Liste.Count() == 0 || Serie.getSerie() != Liste.Last().getSerie())
                {
                    Liste.Add(Serie);
                }

            }
            conn.Close();
            return Liste;
        }

        protected Status getStatusByID(int ID)
        {
            Status Status = new Status(ID);
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getStatusByID";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Status.setStatus(reader.GetString(0));
            }
            conn.Close();
            return Status;
        }

        protected Country landNachIdAusgeben(int ID)
        {
            Country Land = new Country();
            Land.setID(ID);
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getCountryById";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Land.setCountry(reader.GetString(0));
            }
            conn.Close();
            return Land;
        }

        protected List<Sprache> listAnsprechpartnerSprache(int ID)
        {
            List<Sprache> Liste = new List<Sprache>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listAnsprechpartnerSprache";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Sprache S = new Sprache();
                S.setID(reader.GetInt32(0));
                S.setSprache(reader.GetString(1));
                Liste.Add(S);
            }
            conn.Close();
            return Liste;
        }

        public List<Hersteller> listHersteller()
        {
            List<Hersteller> Liste = new List<Hersteller>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listHersteller";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Hersteller A = new Hersteller(-1);
                A.setID(reader.GetInt32(0));
                A.setName(reader.GetString(1));
                Liste.Add(A);
            }
            conn.Close();
            return Liste;
        }

        protected List<Hersteller> listHersteller(Profil P)
        {
            List<Hersteller> Liste = new List<Hersteller>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listProfilHersteller";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", P.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Hersteller A = new Hersteller(-1);
                A.setID(reader.GetInt32(0));
                A.setName(reader.GetString(1));
                Liste.Add(A);
            }
            conn.Close();
            return Liste;
        }

        protected List<Hersteller> getHersteller(Serie S)
        {
        List<Hersteller> Liste = new List<Hersteller>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listHerstellerBySerie";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", S.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Hersteller A = new Hersteller(-1);
                A.setID(reader.GetInt32(0));
                A.setName(reader.GetString(1));
                Liste.Add(A);
            }
            conn.Close();
            return Liste;
        }

        protected List<Ansprechpartner> listAnsprechpartner(Hersteller H)
        {
            List<Ansprechpartner> Liste = new List<Ansprechpartner>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listHerstellerAnsprechpartner";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", H.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Ansprechpartner A = new Ansprechpartner(reader.GetInt32(0));
                A.setGeschlecht(getGeschlechtByID(reader.GetInt32(1)));
                A.setVorname(reader.GetString(2));
                A.setNachname(reader.GetString(3));
                A.setTitel(reader.GetString(4));
                A.setFachbereich(reader.GetString(5));
                A.setTelefon1(reader.GetString(6));
                A.setTelefon2(reader.GetString(7));
                A.setEmail(reader.GetString(8));
                A.setFax(reader.GetString(9));
                A.setKommentar(reader.GetString(10));
                A.setSprache(listAnsprechpartnerSprache(A.getID()));
            }
            conn.Close();
            return Liste;
        }

        protected List<Ansprechpartner> listAnsprechpartner(Kunde K)
        {
            List<Ansprechpartner> Liste = new List<Ansprechpartner>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listKundeAnsprechpartner";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", K.getKundennummer());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Ansprechpartner A = new Ansprechpartner(reader.GetInt32(0));
                A.setGeschlecht(getGeschlechtByID(reader.GetInt32(1)));
                A.setVorname(reader.GetString(2));
                A.setNachname(reader.GetString(3));
                A.setTitel(reader.GetString(4));
                A.setFachbereich(reader.GetString(5));
                A.setTelefon1(reader.GetString(6));
                A.setTelefon2(reader.GetString(7));
                A.setEmail(reader.GetString(8));
                A.setFax(reader.GetString(9));
                A.setKommentar(reader.GetString(10));
                A.setSprache(listAnsprechpartnerSprache(A.getID()));
            }
            conn.Close();
            return Liste;
        }

        public List<Profil> listProfileAusgecheckt(Benutzer User)
        {
            List<Profil> Liste = new List<Profil>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listProfileAusgechecktByUser";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@UserID", User.getMitarbeiternummer());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while(reader.Read())
            {
                Profil P = new Profil(reader.GetInt32(0));
                P.setBezeichnung(reader.GetString(1));
                Liste.Add(P);
            }
            conn.Close();
            return Liste;
        }

        protected List<VerwendungPosition> listProfilEinbaulagen(Profil P)
        {
            List<VerwendungPosition> Liste = new List<VerwendungPosition>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listProfilEinbaulagen";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", P.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                VerwendungPosition V = new VerwendungPosition(reader.GetInt32(0));
                V.setVerwendungPosition(reader.GetString(1));
                Liste.Add(V);
            }
            conn.Close();
            return Liste;
        }

        protected List<Fuellmaterial> listProfilFuellmaterial(Profil P)
        {
            List<Fuellmaterial> Liste = new List<Fuellmaterial>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listProfilFuellmaterial";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", P.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                byte[] Layer = null;
                Layer = (byte[])reader[2];
                MemoryStream mstream = new MemoryStream();
                mstream.Write(Layer, 0, Layer.Length);
                DxfReader dxfread = new DxfReader(mstream);
                DxfModel Data = dxfread.Read();
                mstream.Flush();
                mstream.Close();
                Fuellmaterial F = new Fuellmaterial(reader.GetInt32(0));
                F.setFuellmaterial(reader.GetString(1));
                F.setLayer(Data);
                Liste.Add(F);
            }
            conn.Close();
            return Liste;
        }

        protected List<Hersteller> listProfilHersteller(Profil P)
        {
            List<Hersteller> Liste = new List<Hersteller>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listProfilHersteller";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", P.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Hersteller H = new Hersteller(reader.GetInt32(0));
                H.setName(reader.GetString(1));
                if (Liste.Count() == 0 || H.getID() != Liste.Last().getID())
                {
                    Liste.Add(H);
                }
              
            }
            conn.Close();
            return Liste;
        }

        protected List<Bearbeitungen> listProfilBearbeitungen(Profil P)
        {
            List<Bearbeitungen> Liste = new List<Bearbeitungen>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listProfilBearbeitungen";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", P.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                byte[] Layer = null;
                Layer = (byte[])reader[6];
                MemoryStream mstream = new MemoryStream();
                mstream.Write(Layer, 0, Layer.Length);
                DxfReader dxfread = new DxfReader(mstream);
                DxfModel Data = dxfread.Read();
                mstream.Flush();
                mstream.Close();
                Bearbeitungen B = new Bearbeitungen(reader.GetInt32(0));
                B.setBearbeitungsnummer(reader.GetInt32(1));
                B.setBearbeitungsname(reader.GetString(2));
                B.setWerzeug(getWerkzeugByID(reader.GetInt32(3)));
                B.setBearbeitungswinkel(reader.GetString(4));
                B.setKommentar(reader.GetString(5));
                B.setLayer(Data);
                Liste.Add(B);
            }
            conn.Close();
            return Liste;
        }

        protected List<Beschichtungen> listProfilBeschichtungen(Profil P)
        {
            List<Beschichtungen> Liste = new List<Beschichtungen>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listProfilBeschichtungen";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", P.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Beschichtungen B = new Beschichtungen(reader.GetInt32(0));
                B.setBeschichtungen(reader.GetString(1));
                Liste.Add(B);
            }
            conn.Close();
            return Liste;
        }

        protected List<Dichtung> listProfilDichtungen(Profil P)
        {
            List<Dichtung> Liste = new List<Dichtung>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listProfilDichtungen";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", P.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                byte[] Layer = null;
                Layer = (byte[])reader[2];
                MemoryStream mstream = new MemoryStream();
                mstream.Write(Layer, 0, Layer.Length);
                DxfReader dxfread = new DxfReader(mstream);
                DxfModel Data = dxfread.Read();
                mstream.Flush();
                mstream.Close();
                Dichtung D = new Dichtung(reader.GetInt32(0));
                D.setDichtung(reader.GetString(1));
                D.setDichtungslayer(Data);
                Liste.Add(D);
            }
            return Liste;
        }

        protected List<Restriktion> listProfilRestriktionen(Profil P)
        {
            List<Restriktion> Liste = new List<Restriktion>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listProfilRestriktionen";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", P.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Restriktion R = new Restriktion(reader.GetInt32(0));
                R.setArtikelnummer(reader.GetInt32(1));
                R.setRestriktion(reader.GetString(2));
                Liste.Add(R);
            }
            conn.Close();
            return Liste;
        }

        protected List<Serie> listProfilSerien(Profil P)
        {
            List<Serie> Liste = new List<Serie>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listProfilSerien";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", P.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Serie S = new Serie(reader.GetInt32(0));
                S.setSerie(reader.GetString(1));
                if (Liste.Count() == 0 || S.getID() != Liste.Last().getID())
                {
                    Liste.Add(S);
                }
                              
            }
            conn.Close();
            return Liste;
        }

        protected List<Werkstoff> listProfilWerkstoff(Profil P)
        {
            List<Werkstoff> Liste = new List<Werkstoff>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listProfilWerkstoff";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", P.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Werkstoff W = new Werkstoff(reader.GetInt32(0));
                W.setWerkstoff(reader.GetString(1));
                Liste.Add(W);
            }
            conn.Close();
            return Liste;
        }

        protected List<Bearbeitungen> listTeilBearbeitungen(Teil T)
        {
            List<Bearbeitungen> Liste = new List<Bearbeitungen>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listTeilBearbeitungen";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", T.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Bearbeitungen B = new Bearbeitungen(reader.GetInt32(0));
                B.setBearbeitungsnummer(reader.GetInt32(1));
                B.setBearbeitungsname(reader.GetString(2));
                B.setWerzeug(getWerkzeugByID(reader.GetInt32(3)));
                B.setBearbeitungswinkel(reader.GetString(4));
                B.setKommentar(reader.GetString(5));
                byte[] Layer = null;
                Layer = (byte[])reader[6];
                MemoryStream mstream = new MemoryStream();
                mstream.Write(Layer, 0, Layer.Length);
                DxfReader dxfread = new DxfReader(mstream);
                DxfModel Data = dxfread.Read();
                mstream.Flush();
                mstream.Close();
                B.setLayer(Data);
                Liste.Add(B);
            }
            conn.Close();
            return Liste;
        }

        protected List<Beschichtungen> listTeilBeschichtungen(Teil T)
        {
            List<Beschichtungen> Liste = new List<Beschichtungen>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listTeilBeschichtungen";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", T.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Beschichtungen B = new Beschichtungen(reader.GetInt32(0));
                B.setBeschichtungen(reader.GetString(1));
                Liste.Add(B);
            }
            conn.Close();
            return Liste;
        }

        protected List<Dichtung> listTeilDichtungen(Teil T)
        {
            List<Dichtung> Liste = new List<Dichtung>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listTeilDichtungen";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", T.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Dichtung D = new Dichtung(reader.GetInt32(0));
                D.setDichtung(reader.GetString(1));
                byte[] Layer = null;
                Layer = (byte[])reader[2];
                MemoryStream mstream = new MemoryStream();
                mstream.Write(Layer, 0, Layer.Length);
                DxfReader dxfread = new DxfReader(mstream);
                DxfModel Data = dxfread.Read();
                mstream.Flush();
                mstream.Close();
                D.setDichtungslayer(Data);
                Liste.Add(D);
            }
            conn.Close();
            return Liste;
        }

        protected List<Werkstoff> listTeilWerkstoff(Teil T)
        {
            List<Werkstoff> Liste = new List<Werkstoff>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listTeilWerkstoff";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", T.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Werkstoff W = new Werkstoff(reader.GetInt32(0));
                W.setWerkstoff(reader.GetString(1));
                Liste.Add(W);
            }
            conn.Close();
            return Liste;
        }

        protected List<Restriktion> listTeilRestriktionen(Teil T)
        {
            List<Restriktion> Liste = new List<Restriktion>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listTeilRestriktionen";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", T.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Restriktion R = new Restriktion(reader.GetInt32(0));
                R.setArtikelnummer(reader.GetInt32(1));
                R.setRestriktion(reader.GetString(2));
                Liste.Add(R);
            }
            conn.Close();
            return Liste;
        }

        protected List<Fuellmaterial> listTeilFuellmaterial(Teil T)
        {
            List<Fuellmaterial> Liste = new List<Fuellmaterial>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listTeilFuellmaterial";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", T.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Fuellmaterial F = new Fuellmaterial(reader.GetInt32(0));
                F.setFuellmaterial(reader.GetString(1));
                byte[] Layer = null;
                Layer = (byte[])reader[2];
                MemoryStream mstream = new MemoryStream();
                mstream.Write(Layer, 0, Layer.Length);
                DxfReader dxfread = new DxfReader(mstream);
                DxfModel Data = dxfread.Read();
                mstream.Flush();
                mstream.Close();
                F.setLayer(Data);
                Liste.Add(F);
            }
            conn.Close();
            return Liste;
        }

        protected List<VerwendungPosition> listTeilEinbaulagen(Teil T)
        {
            List<VerwendungPosition> Liste = new List<VerwendungPosition>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listTeilEinbaulagen";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", T.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                VerwendungPosition V = new VerwendungPosition(reader.GetInt32(0));
                V.setVerwendungPosition(reader.GetString(1));
                Liste.Add(V);
            }
            conn.Close();
            return Liste;
        }

        //
        //
        //Program Functions
        //
        //
        public List<Rolle> alleRollenAusgeben()
        {
            List<Rolle> Liste = new List<Rolle>();          
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAllRollen";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Rolle Rolle = new Rolle();
                Rechte Rechte = new Rechte();
                Rolle.setid(reader.GetInt32(0));
                Rolle.setRollenbezeichnung(reader.GetString(1));
                Rolle.setPasswort(reader.GetString(2));
                Rechte.setRechteString(reader.GetString(3));
                Rolle.setRechte(Rechte);
                Liste.Add(Rolle);
            }
            conn.Close();
            return Liste;
        }

        public void createLand(List<Country> Countrys)
        {
            int i = Countrys.Count;
            while (i != 0)
            {
                Country Co = Countrys.First();
                string Countryname = Co.getCountry();
                createCountry(Countryname);
                Countrys.RemoveAt(0);
                i = i - 1;
            }
        }

        public List<Country> alleLaenderAusgeben()
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAllCountry";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();


            List<Country> CouList = new List<Country>();
            while (reader.Read())
            {
                int ID = reader.GetInt32(0);
                string Name = reader.GetString(1);
                Country Ges = new Country();
                Ges.setID(ID);
                Ges.setCountry(Name);
                CouList.Add(Ges);
            }
            conn.Close();
            return CouList;
        }

        public List<Sprache> alleSprachenAusgeben()
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getalllanguages";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();

            List<Sprache> Liste = new List<Sprache>();
            while (reader.Read())
            {
                Sprache Spra = new Sprache();
                Spra.setID(reader.GetInt32(0));
                Spra.setSprache(reader.GetString(1));
                Liste.Add(Spra);
            }
            conn.Close();
            return Liste;
        }

        public List<Geschlecht> alleGeschlechterAusgeben()
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAllSexes";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();

            List<Geschlecht> GesList = new List<Geschlecht>();
            while (reader.Read())
            {
                int ID = reader.GetInt32(0);
                string Name = reader.GetString(1);
                Geschlecht Ges = new Geschlecht();
                Ges.setID(ID);
                Ges.setGeschlecht(Name);
                GesList.Add(Ges);
            }
            conn.Close();
            return GesList;
        }

        public void herstellerEintragen(Hersteller Herst)
        {
            int Herstellernummer = Herst.getID();
            string Name = Herst.getName();
            string AddL1 = Herst.getAdressline1();
            string AddL2 = Herst.getAdressline2();
            string City = Herst.getCity();
            string State = Herst.getState();
            string PLZ = Herst.getPostcode();
            int Country = Herst.getCountry().getID();
            createHersteller(Herstellernummer, Name, AddL1, AddL2, City, State, PLZ, Country);

            //Ansprechpartner Eintragen
            List<Ansprechpartner> Ansprechpartnerliste = new List<Ansprechpartner>(Herst.getAnsprechpartner());
            int CountA = Ansprechpartnerliste.Count;
            while (CountA != 0)
            {
                int ID = new int();
                Ansprechpartner Partner = Ansprechpartnerliste.First();
                ID = AnsprechpartnerEintragen(Partner);
                //Ansprechpartner Verknüpfen
                addHerstellerAnsprechpartner(Herstellernummer, ID);
                Ansprechpartnerliste.RemoveAt(0);
                CountA = CountA - 1;
            }

        }

        public Hersteller herstellerAbfragenID(int ID)
        {
            Hersteller Hersteller = new Hersteller(ID);
            int LandID = new int();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getHerstellerById";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Hersteller.setName(reader.GetString(0));
                Hersteller.setAdressline1(reader.GetString(1));
                Hersteller.setAdressline2(reader.GetString(2));
                Hersteller.setCity(reader.GetString(3));
                Hersteller.setState(reader.GetString(4));
                Hersteller.setPostcode(reader.GetString(5));
                LandID = reader.GetInt32(6);
            }
            conn.Close();
            Hersteller.setCountry(landNachIdAusgeben(LandID));

            //Ansprechpartner Liste ausgeben
            List<Ansprechpartner> AListe = new List<Ansprechpartner>();
            SqlConnection conn2 = new SqlConnection(connString);
            SqlCommand command2 = conn2.CreateCommand();
            command2.CommandText = "getAllAnsprechpartnerFromHersteller";
            command2.CommandType = System.Data.CommandType.StoredProcedure;
            command2.Parameters.AddWithValue("@ID", ID);
            conn2.Open();
            SqlDataReader reader2 = command2.ExecuteReader();
            while (reader2.Read())
            {
                AListe.Add(getAnsprechpartnerByID(reader2.GetInt32(0)));
            }
            conn2.Close();
            Hersteller.setAnsprechpartner(AListe);
            return Hersteller;
        }

        public void herstellerBearbeiten(Hersteller Herst)
        {
            int Herstellernummer = Herst.getID();
            string Name = Herst.getName();
            string AddL1 = Herst.getAdressline1();
            string AddL2 = Herst.getAdressline2();
            string City = Herst.getCity();
            string State = Herst.getState();
            string PLZ = Herst.getPostcode();
            int Country = Herst.getCountry().getID();
            changeHersteller(Herstellernummer, Name, AddL1, AddL2, City, State, PLZ, Country);

            //Ansprechpartner Eintragen
            List<Ansprechpartner> Ansprechpartnerliste = new List<Ansprechpartner>(Herst.getAnsprechpartner());
            int CountA = Ansprechpartnerliste.Count;
            while (CountA != 0)
            {
                if (Ansprechpartnerliste.First().getID() != -1)
                {
                    AnsprechpartnerBearbeiten(Ansprechpartnerliste.First());
                    Ansprechpartnerliste.RemoveAt(0);
                    CountA = CountA - 1;
                }
                else
                {
                    int ID = new int();
                    Ansprechpartner Partner = Ansprechpartnerliste.First();
                    ID = AnsprechpartnerEintragen(Partner);
                    //Ansprechpartner Verknüpfen
                    addHerstellerAnsprechpartner(Herstellernummer, ID);
                    Ansprechpartnerliste.RemoveAt(0);
                    CountA = CountA - 1;
                }
                
            }

        }

        public void HerstellerLoeschen(Hersteller H)
        {
            //Profile löschen
            List<Profil> PListe = new List<Profil>();
            PListe = getProfileByHersteller(H);
            int Pi = new int();
            Pi = PListe.Count();
            while (Pi != 0)
            {
                List<Hersteller> HListe = new List<Hersteller>();
                HListe = listHersteller(PListe.First());
                if (HListe.Count() == 1)
                {
                    ProfilLoeschen(PListe.First());
                }
                PListe.RemoveAt(0);
                Pi = Pi - 1;
            }
            //Ansprechpartner löschen
            List<Ansprechpartner> AListe = new List<Ansprechpartner>();
            AListe = listAnsprechpartner(H);
            int Ai = new int();
            Ai = AListe.Count();
            while (Ai != 0)
            {
                AnsprechpartnerLoeschen(AListe.First());
                AListe.RemoveAt(0);
                Ai = Ai - 1;
            }
            //Serien löschen
            List<Serie> SListe = new List<Serie>();
            SListe = getHerstellerserien(H);
            int Si = new int();
            Si = SListe.Count();
            while (Si != 0)
            {
                List<Hersteller> HListe = new List<Hersteller>();
                HListe = getHersteller(SListe.First());
                if (HListe.Count() == 1)
                {
                    deleteSerie(SListe.First());
                }
                SListe.RemoveAt(0);
                Si = Si - 1;
            }

            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "deleteHersteller";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", H.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close(); 
        }

        public void kundeEintragen(Kunde Kunde)
        {
            int Kundennummer = Kunde.getKundennummer();
            string Name = Kunde.getName();
            List<Kunde> Liste = new List<Kunde>();
            Liste = alleKundenAusgeben();
            Boolean JaNein = new Boolean();
            JaNein = false;
            for (int i = 0; i < Liste.Count; i++)
            {
                if (Kunde.getKundennummer() == Liste[i].getKundennummer())
                {
                    JaNein = true;
                }
            }

            if (JaNein == false)
            {

                SqlConnection conn = new SqlConnection(connString);
                SqlCommand command = conn.CreateCommand();
                command.CommandText = "createKunde";
                command.CommandType = System.Data.CommandType.StoredProcedure;
                command.Parameters.AddWithValue("@ID", Kundennummer);
                command.Parameters.AddWithValue("@Name", Name);
                conn.Open();
                SqlDataReader reader = command.ExecuteReader();
                conn.Close(); 
            }

            //Ansprechpartner Eintragen
            List<Ansprechpartner> Ansprechpartnerliste = new List<Ansprechpartner>();
            Ansprechpartnerliste = Kunde.getAnsprechpartner();
            int CountA = Ansprechpartnerliste.Count;
            while (CountA != 0)
            {
                int ID = new int();
                Ansprechpartner Partner = Ansprechpartnerliste.First();
                ID = AnsprechpartnerEintragen(Partner);
                //Ansprechpartner Verknüpfen
                addKundeAnsprechpartner(Kundennummer, ID);
                Ansprechpartnerliste.RemoveAt(0);
                CountA = CountA - 1;
            }

        }

        public void KundeLoeschen(Kunde K)
        {
            List<Ansprechpartner> AListe = new List<Ansprechpartner>();
            AListe = listAnsprechpartner(K);
            int Ai = new int();
            Ai = AListe.Count();
            while (Ai !=0)
            {
                AnsprechpartnerLoeschen(AListe.First());
                AListe.RemoveAt(0);
                Ai = Ai - 1;
            }
            List<Serie> SListe = new List<Serie>();
            SListe = getKundenserien(K);
            int Si = new int();
            Si = SListe.Count();
            while (Si !=0)
            {
                deleteKundenserie(SListe.First());
                SListe.RemoveAt(0);
                Si = Si - 1;
            }
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "deleteKunde";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", K.getKundennummer());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close(); 
        }

        public void kundeBearbeiten(Kunde Alter, Kunde Neuer)
        {
            List<Kunde> Liste = new List<Kunde>();
            Liste = alleKundenAusgeben();
            Boolean JaNein = new Boolean();
            JaNein = false;
            for (int i = 0; i < Liste.Count; i++)
            {
                if (Neuer.getKundennummer() == Liste[i].getKundennummer())
                {
                    JaNein = true;
                }
            }

            if (JaNein == false)
            {

                SqlConnection conn = new SqlConnection(connString);
                SqlCommand command = conn.CreateCommand();
                command.CommandText = "createKunde";
                command.CommandType = System.Data.CommandType.StoredProcedure;
                command.Parameters.AddWithValue("@Alt", Alter.getKundennummer());
                command.Parameters.AddWithValue("@Neu", Neuer.getKundennummer());
                command.Parameters.AddWithValue("@Name", Neuer.getName());
                conn.Open();
                SqlDataReader reader = command.ExecuteReader();
                conn.Close();
            }
            //Ansprechpartner löschen
            List<Ansprechpartner> AListe = new List<Ansprechpartner>(Alter.getAnsprechpartner());
            int CountB = AListe.Count;
            while (CountB != 0)
            {
                AnsprechpartnerLoeschen(AListe.First());
                AListe.RemoveAt(0);
                CountB = CountB - 1;
            }

            //Ansprechpartner Eintragen
            List<Ansprechpartner> Ansprechpartnerliste = new List<Ansprechpartner>(Neuer.getAnsprechpartner());
            int CountA = Ansprechpartnerliste.Count;
            while (CountA != 0)
            {
                int ID = new int();
                Ansprechpartner Partner = Ansprechpartnerliste.First();
                ID = AnsprechpartnerEintragen(Partner);
                //Ansprechpartner Verknüpfen
                addKundeAnsprechpartner(Neuer.getKundennummer(), ID);
                Ansprechpartnerliste.RemoveAt(0);
                CountA = CountA - 1;
            }
        }

        public List<Auftrag> kundeAuftraegeAuslesen(Kunde Kunde)
        { 
            List<Auftrag> Liste = new List<Auftrag>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAllAuftraegeByKunde";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", Kunde.getKundennummer());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Auftrag A = new Auftrag(reader.GetInt32(0));
                Zustand Z = new Zustand(-1);
                Z = getZustand(reader.GetInt32(1));
                A.setZustand(Z);
                Liste.Add(A);
            }
            return Liste;
        }

        public List<Teil> kundeTeileAuslesen(Kunde Kunde)
        {
            List<Teil> Liste = new List<Teil>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAllTeileByKunde";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", Kunde.getKundennummer());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Teil T = new Teil(reader.GetInt32(0));
                T.setKundenbezeichnung(reader.GetString(1));
                T.setKundenserie(getKundenserie(reader.GetInt32(2)));
                Profil P = new Profil(reader.GetInt32(3));
                P.setBezeichnung(reader.GetString(4));
                T.setProfil(P);
                Liste.Add(T);
            }
            return Liste;
        }

        public void rolleAendern(Rolle Rolle)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "changeRolle";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", Rolle.getid());
            command.Parameters.AddWithValue("@Name", Rolle.getRollenbezeichnung());
            command.Parameters.AddWithValue("@Pw", Rolle.getPasswort());
            command.Parameters.AddWithValue("@Rechte", Rolle.getRechte().getRechteString());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
        }

        public int rolleEintragen(Rolle Rolle)
        {
            int ID = new int();
            string PW = Rolle.getPasswort();
            string Name = Rolle.getRollenbezeichnung();
            string Rechte = Rolle.getRechte().getRechteString();
            ID = createRolle(Name, PW, Rechte);
            return ID;
        }

        protected void removeProfilFromSerie(Serie S, Profil P)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "removeProfilFromSerie";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Profil", P.getID());
            command.Parameters.AddWithValue("@Serie", S.getID());

            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
        }

        protected void removeProfilBeschichtung(Profil P,Beschichtungen B)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "removeProfilBeschichtung";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Profil", P.getID());
            command.Parameters.AddWithValue("@Bes", B.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
        }

        protected void removeProfilWerkstoff(Profil P, Werkstoff B)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "removeProfilWerkstoff";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Profil", P.getID());
            command.Parameters.AddWithValue("@W", B.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
        }

        protected void removeProfilHersteller(Profil P, Hersteller H)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "removeProfilWerkstoff";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Profil", P.getID());
            command.Parameters.AddWithValue("@W", H.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
        }

        protected void removeProfilEinbaulagen(Profil P)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "removeProfilEinbaulagen";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", P.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
        }

        protected void removeProfilEinbaulage(Profil P, VerwendungPosition E)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "removeProfilEinbaulage";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", P.getID());
            command.Parameters.AddWithValue("@EID", E.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
        }
        

        protected int booltoint(bool B)
        { 
            int i = new int(); 
            if(B) 
            { 
                i = 1; 
            } 
            else 
            { 
                i=0; 
            }
            return i;
        }

        protected bool inttobool(int i)
        { 
            bool b = new bool();
            if (i == 0)
            {
                b = false;
            }
            else
            {
                b = true;
            }
            return b;
        }

        public void benutzerEintragen(Benutzer User)
        {
            int ID = User.getMitarbeiternummer();
            string Name = User.getbenutzername();
            int Rolle = User.getRolle().getid();
            createBenutzer(ID, Name, Rolle);
        }

        public void benutzerLoeschen(Benutzer User)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "deleteBenutzer";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", User.getMitarbeiternummer());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
        }

        public int ProfilEintragen(Profil Profil)
        {
            int ProfilID = new int();
            ProfilID = Profil.getID();
            if (Profil.getID() == -1)
            {
                //Profiltabelleneintrag
                string Bezeichnung = Profil.getBezeichnung();
                decimal Hoehe = Profil.getHoeheAbs();
                decimal Tiefe = Profil.getTiefeAbs();
                int Typ = booltoint(Profil.getRahmenFenster());
                int EV = Profil.getErstelltVon().getMitarbeiternummer();
                DateTime EW = Profil.getErstelltWann();
                int FV = Profil.getFreigabeVon().getMitarbeiternummer();
                DateTime FW = Profil.getFreigabeWann();
                string Kommentar = Profil.getKommentar();
                DxfModel Layer = Profil.getZeichnung();
                ProfilID = createProfil(Bezeichnung, Hoehe, Tiefe, Typ, EV, EW, FV, FW, Kommentar, Layer);


                //Einbaulagen Eintragen
                List<VerwendungPosition> EinbaulagenListe = new List<VerwendungPosition>(Profil.getVerwendungsposition());
                int CountE = EinbaulagenListe.Count;
                while (CountE != 0)
                {
                    //Einbaulage Verknüpfen
                    addProfilEinbaulage(ProfilID, EinbaulagenListe.First().getID());
                    EinbaulagenListe.RemoveAt(0);
                    CountE = CountE - 1;
                }

                //Dichtungen Eintragen
                List<Dichtung> DichtungListe = new List<Dichtung>(Profil.getDichtung());
                int CountD = DichtungListe.Count;
                while (CountD != 0)
                {
                    int ID = new int();
                    ID = createDichtung(DichtungListe.First());
                    //Dichtung Verknüpfen
                    addProfilDichtung(ProfilID, ID);
                    DichtungListe.RemoveAt(0);
                    CountD = CountD - 1;
                }

                //Restriktionen Eintragen
                List<Restriktion> RestriktionenListe = new List<Restriktion>(Profil.getRestriktion());
                int CountR = RestriktionenListe.Count;
                while (CountR != 0)
                {
                    if (RestriktionenListe.First().getID() == -1)
                    {
                        RestriktionenListe.First().setID(createRestriktion(RestriktionenListe.First()));
                    }
                    //Restriktion Verknüpfen
                    addProfilRestriktion(ProfilID, RestriktionenListe.First().getID());
                    RestriktionenListe.RemoveAt(0);
                    CountR = CountR - 1;
                }

                //Beschichtungen Eintragen
                List<Beschichtungen> Beschichtungsliste = new List<Beschichtungen>(Profil.getBeschichtungen());
                int CountBes = Beschichtungsliste.Count;
                while (CountBes != 0)
                {
                    //Beschichtung Verknüpfen
                    addProfilBeschichtung(ProfilID, Beschichtungsliste.First().getID());
                    Beschichtungsliste.RemoveAt(0);
                    CountBes = CountBes - 1;
                }

                //Werkstoffe Abarbeiten
                List<Werkstoff> Werkstoffliste = new List<Werkstoff>(Profil.getWerkstoff());
                int CountW = Werkstoffliste.Count;
                while (CountW != 0)
                {
                    //Werkstoff Verknüpfen
                    addProfilWerkstoff(ProfilID, Werkstoffliste.First().getID());
                    Werkstoffliste.RemoveAt(0);
                    CountW = CountW - 1;
                }

                //Fuellmaterilien Eintragen
                List<Fuellmaterial> Fuellmaterialliste = new List<Fuellmaterial>(Profil.getFuellmaterial());
                int CountF = Fuellmaterialliste.Count;
                while (CountF != 0)
                {
                    int ID = new int();
                    ID = createFuellmaterial(Fuellmaterialliste.First());
                    //Fuellmaterial Verknüpfen
                    addProfilFuellmaterial(ProfilID, ID);
                    Fuellmaterialliste.RemoveAt(0);
                    CountF = CountF - 1;
                }

                //Bearbeitungen Eintragen
                List<Bearbeitungen> BearbeitungsListe = new List<Bearbeitungen>(Profil.getBearbeitungen());
                int CountB = BearbeitungsListe.Count();
                while (CountB != 0)
                {
                    int ID = new int();
                    ID = createBearbeitung(BearbeitungsListe.First());
                    //Bearbeitung Verknüpfen
                    addProfilBearbeitung(ProfilID, ID);
                    BearbeitungsListe.RemoveAt(0);
                    CountB = CountB - 1;
                }

                //Hersteller eintragen
                List<Hersteller> HerstellerListe = new List<Hersteller>(Profil.getAlleHersteller());
                int CountH = HerstellerListe.Count;
                while (CountH != 0)
                {
                    Hersteller Hersteller = HerstellerListe.First();
                    addProfilHersteller(ProfilID, Hersteller.getID());
                    HerstellerListe.RemoveAt(0);
                    CountH = CountH - 1;
                }

                //Serie Eintragen
                List<Serie> Serienliste = new List<Serie>(Profil.getSerie());
                int CountS = Serienliste.Count();
                while (CountS != 0)
                {
                    //Serie Verknüpfen
                    addProfilSerie(ProfilID, Serienliste.First().getID());
                    Serienliste.RemoveAt(0);
                    CountS = CountS - 1;
                }
            }
            else
            {
                ProfilAendern(Profil);
            }
            
            return ProfilID;
        }

        protected void ProfilAendern(Profil Profil)
        {
            //Profiltabelleneintrag
            changeProfil(Profil);
            //
            //Einbaulagen Eintragen
            //
            List<VerwendungPosition> VerwendungPositionListe = new List<VerwendungPosition>(Profil.getVerwendungsposition());
            List<VerwendungPosition> VergeichsListeE = new List<VerwendungPosition>(listProfilEinbaulagen(Profil));
            List<VerwendungPosition> Templiste1E = new List<VerwendungPosition>(VerwendungPositionListe);
            //gucken was neu muss
            while (Templiste1E.Count() != 0)
            {
                if (!VergeichsListeE.Contains(Templiste1E.First(), new VerwendungPositioncomparer()))
                {
                    addProfilEinbaulage(Profil.getID(), Templiste1E.First().getID());
                }
                Templiste1E.RemoveAt(0);
            }
            //Aussortieren was weg kann
            Templiste1E = new List<VerwendungPosition>(VergeichsListeE);
            while (Templiste1E.Count() != 0)
            {
                if (!VerwendungPositionListe.Contains(Templiste1E.First(), new VerwendungPositioncomparer()))
                {
                    removeProfilEinbaulage(Profil, Templiste1E.First());
                }
                Templiste1E.RemoveAt(0);
            }
            //
            //Dichtungen Eintragen
            //
            List<Dichtung> DichtungListe = new List<Dichtung>(Profil.getDichtung());
            List<Dichtung> VergeichsListe = new List<Dichtung>(listProfilDichtungen(Profil));
            List<Dichtung> Templiste1 = new List<Dichtung>(DichtungListe);
                //gucken was neu muss
            while (Templiste1.Count != 0)
            {
                if (!VergeichsListe.Contains(Templiste1.First(), new Dichtungcomparer()))
                {
                    addProfilDichtung(Profil.getID(), createDichtung(Templiste1.First()));
                }
                Templiste1.RemoveAt(0);
            }
                //Aussortieren was weg kann
            Templiste1 = new List<Dichtung>(VergeichsListe);
            while (Templiste1.Count() != 0)
            {
                if (!DichtungListe.Contains(Templiste1.First(), new Dichtungcomparer()))
                {
                    deleteDichtung(Templiste1.First());
                }
                Templiste1.RemoveAt(0);                
            }

            //
            //Restriktionen Eintragen
            //
            List<Restriktion> RestriktionListe = new List<Restriktion>(Profil.getRestriktion());
            List<Restriktion> VergeichsListeR = new List<Restriktion>(listProfilRestriktionen(Profil));
            List<Restriktion> Templiste1R = new List<Restriktion>(RestriktionListe);
                //gucken was neu muss
            while (Templiste1R.Count != 0)
            {
                if (!VergeichsListeR.Contains(Templiste1R.First(), new Restriktioncomparer()))
                {
                    addProfilRestriktion(Profil.getID(), createRestriktion(Templiste1R.First()));
                }
                Templiste1R.RemoveAt(0);
            }
                //Aussortieren was weg kann
            Templiste1R = new List<Restriktion>(VergeichsListeR);
            while (Templiste1R.Count() != 0)
            {
                if (!RestriktionListe.Contains(Templiste1R.First(), new Restriktioncomparer()))
                {
                    deleteRestriktion(Templiste1R.First());
                }
                Templiste1R.RemoveAt(0);
            }

            //
            //Beschichtungen Eintragen
            //
            List<Beschichtungen> BeschichtungenListe = new List<Beschichtungen>(Profil.getBeschichtungen());
            List<Beschichtungen> VergeichsListeBes = new List<Beschichtungen>(listProfilBeschichtungen(Profil));
            List<Beschichtungen> Templiste1Bes = new List<Beschichtungen>(BeschichtungenListe);
            //gucken was neu muss
            while (Templiste1Bes.Count != 0)
            {
                if (!VergeichsListeBes.Contains(Templiste1Bes.First(), new Beschichtungscomparer()))
                {
                    addProfilBeschichtung(Profil.getID(), Templiste1Bes.First().getID());
                }
                Templiste1Bes.RemoveAt(0);
            }
            //Aussortieren was weg kann
            Templiste1Bes = new List<Beschichtungen>(VergeichsListeBes);
            while (Templiste1Bes.Count() != 0)
            {
                if (!BeschichtungenListe.Contains(Templiste1Bes.First(), new Beschichtungscomparer()))
                {
                    removeProfilBeschichtung(Profil,Templiste1Bes.First());
                }
                Templiste1Bes.RemoveAt(0);
            }

            //
            //Werkstoffe Abarbeiten
            //
            List<Werkstoff> WerkstoffListe = new List<Werkstoff>(Profil.getWerkstoff());
            List<Werkstoff> VergeichsListeW = new List<Werkstoff>(listProfilWerkstoff(Profil));
            List<Werkstoff> Templiste1W = new List<Werkstoff>(WerkstoffListe);
            //gucken was neu muss
            while (Templiste1W.Count != 0)
            {
                if (!VergeichsListeW.Contains(Templiste1W.First(), new Werkstoffcomparer()))
                {
                    addProfilWerkstoff(Profil.getID(), Templiste1W.First().getID());
                }
                Templiste1W.RemoveAt(0);
            }
            //Aussortieren was weg kann
            Templiste1W = new List<Werkstoff>(VergeichsListeW);
            while (Templiste1W.Count() != 0)
            {
                if (!WerkstoffListe.Contains(Templiste1W.First(), new Werkstoffcomparer()))
                {
                    removeProfilWerkstoff(Profil, Templiste1W.First());
                }
                Templiste1W.RemoveAt(0);
            }

            //
            //Fuellmaterilien Eintragen
            //
            List<Fuellmaterial> FuellListe = new List<Fuellmaterial>(Profil.getFuellmaterial());
            List<Fuellmaterial> VergeichsListeFu = new List<Fuellmaterial>(listProfilFuellmaterial(Profil));
            List<Fuellmaterial> Templiste1Fu = new List<Fuellmaterial>(FuellListe);
            //gucken was neu muss
            while (Templiste1Fu.Count != 0)
            {
                if (!VergeichsListeFu.Contains(Templiste1Fu.First(), new Fuellmaterialcomparer()))
                {
                    addProfilFuellmaterial(Profil.getID(), createFuellmaterial(Templiste1Fu.First()));
                }
                Templiste1Fu.RemoveAt(0);
            }
            //Aussortieren was weg kann
            Templiste1Fu = new List<Fuellmaterial>(VergeichsListeFu);
            while (Templiste1Fu.Count() != 0)
            {
                if (!FuellListe.Contains(Templiste1Fu.First(), new Fuellmaterialcomparer()))
                {
                    deleteFuellmaterial(Templiste1Fu.First());
                }
                Templiste1Fu.RemoveAt(0);
            }
            //
            //Bearbeitungen Eintragen
            //
            List<Bearbeitungen> Bearbeitungensliste = new List<Bearbeitungen>(Profil.getBearbeitungen());
            List<Bearbeitungen> VergeichsListeBearbeitungen = new List<Bearbeitungen>(listProfilBearbeitungen(Profil));
            List<Bearbeitungen> Templiste1Bearbeitungen = new List<Bearbeitungen>(Bearbeitungensliste);
            //gucken was neu muss
            while (Templiste1Bearbeitungen.Count != 0)
            {
                if (!VergeichsListeBearbeitungen.Contains(Templiste1Bearbeitungen.First(), new Bearbeitungencomparer()))
                {
                    addProfilBearbeitung(Profil.getID(), createBearbeitung(Templiste1Bearbeitungen.First()));
                }
                Templiste1Bearbeitungen.RemoveAt(0);
            }
            //Aussortieren was weg kann
            Templiste1Bearbeitungen = new List<Bearbeitungen>(VergeichsListeBearbeitungen);
            while (Templiste1Bearbeitungen.Count() != 0)
            {
                if (!Bearbeitungensliste.Contains(Templiste1Bearbeitungen.First(), new Bearbeitungencomparer()))
                {
                    deleteBearbeitung(Templiste1Bearbeitungen.First());
                }
                Templiste1Bearbeitungen.RemoveAt(0);
            }
            //
            //Hersteller eintragen
            //
            List<Hersteller> HerstellerListe = new List<Hersteller>(Profil.getAlleHersteller());
            List<Hersteller> VergeichsListeH = new List<Hersteller>(listProfilHersteller(Profil));
            List<Hersteller> Templiste1H = new List<Hersteller>(HerstellerListe);
            //gucken was neu muss
            while (Templiste1H.Count != 0)
            {
                if (!VergeichsListeH.Contains(Templiste1H.First(), new Herstellercomparer()))
                {
                    addProfilHersteller(Profil.getID(), Templiste1H.First().getID());
                }
                Templiste1H.RemoveAt(0);
            }
            //Aussortieren was weg kann
            Templiste1H = new List<Hersteller>(VergeichsListeH);
            while (Templiste1H.Count() != 0)
            {
                if (!HerstellerListe.Contains(Templiste1H.First(), new Herstellercomparer()))
                {
                    removeProfilHersteller(Profil, Templiste1H.First());
                }
                Templiste1H.RemoveAt(0);
            }

            //
            //Serie Eintragen
            //
            List<Serie> SerieListe = new List<Serie>(Profil.getSerie());
            List<Serie> VergeichsListeS = new List<Serie>(listProfilSerien(Profil));
            List<Serie> Templiste1S = new List<Serie>(SerieListe);
            //gucken was neu muss
            while (Templiste1S.Count() != 0)
            {
                if (!VergeichsListeS.Contains(Templiste1S.First(), new Seriecomparer()))
                {
                    addProfilSerie(Profil.getID(), Templiste1S.First().getID());
                }
                Templiste1S.RemoveAt(0);
            }
            //Aussortieren was weg kann
            Templiste1S = new List<Serie>(VergeichsListeS);
            while (Templiste1S.Count() != 0)
            {
                if (!SerieListe.Contains(Templiste1S.First(), new Seriecomparer()))
                {
                        List<Profil> PListe = new List<Profil>();
                        PListe = getProfileBySerie(Templiste1S.First());
                        if (PListe.Count() == 1)
                        {
                            deleteSerie(Templiste1S.First());
                        }
                        else
                        {
                            removeProfilFromSerie(Templiste1S.First(), Profil);
                        }
                    }
                Templiste1S.RemoveAt(0);
            }
        }

        public void ProfilLoeschen(Profil P)
        {
            P = ProfilAusgeben(P.getID());
            //Werkstoffe entfernen
            List<Werkstoff> WListe = new List<Werkstoff>(P.getWerkstoff());
            while (WListe.Count() != 0)
            {
                removeProfilWerkstoff(P, WListe.First());
                WListe.RemoveAt(0);
            }
            //Teile Löschen
            List<Teil> TListe = new List<Teil>(TeileAusgeben(P));
            int i = new int();
            i = TListe.Count();
            while (i != 0)
            {
                Teil T = new Teil(-1);
                T = TListe.First();
                TeilLoeschen(T);
                TListe.RemoveAt(0);
                i = i - 1;
            }
            //Dichtungen Löschen
            List<Dichtung> DListe = new List<Dichtung>(P.getDichtung());
            int Di = new int();
            Di = DListe.Count();
            while (Di != 0)
            {
                Dichtung D = new Dichtung(-1);
                D = DListe.First();
                deleteDichtung(D);
                DListe.RemoveAt(0);
                Di = Di - 1;
            }
            //Bearbeitungen Löschen
            List<Bearbeitungen> BListe = new List<Bearbeitungen>(P.getBearbeitungen());
            int Bi = new int();
            Bi = BListe.Count();
            while (Bi != 0)
            {
                Bearbeitungen B = new Bearbeitungen(-1);
                B = BListe.First();
                deleteBearbeitung(B);
                BListe.RemoveAt(0);
                Bi = Bi - 1;
            }

            //Beschichtungen entfernen
            List<Beschichtungen> BesListe = new List<Beschichtungen>(P.getBeschichtungen());
            while (BesListe.Count() !=0 )
            {
                removeProfilBeschichtung(P, BesListe.First());
                BesListe.RemoveAt(0);
            }

            //Restriktionen Löschen
            List<Restriktion> RListe = new List<Restriktion>(P.getRestriktion());
            int Ri = new int();
            Ri = RListe.Count();
            while (Ri != 0)
            {
                Restriktion R = new Restriktion(-1);
                R = RListe.First();
                deleteRestriktion(R);
                RListe.RemoveAt(0);
                Ri = Ri - 1;
            }
            //Fuellmaterial Löschen
            List<Fuellmaterial> FListe = new List<Fuellmaterial>(P.getFuellmaterial());
            int Fi = new int();
            Fi = FListe.Count();
            while (Fi != 0)
            {
                Fuellmaterial F = new Fuellmaterial(-1);
                F = FListe.First();
                deleteFuellmaterial(F);
                FListe.RemoveAt(0);
                Fi = Fi - 1;
            }
            //Serien Löschen
            List<Serie> SListe = new List<Serie>(P.getSerie());
            int Si = new int();
            Si = SListe.Count();
            while (Si !=0)
            {
                List<Profil> PListe = new List<Profil>();
                //PListe = getProfileBySerie(SListe.First());
                if (PListe.Count() == 1)
	            {
		            deleteSerie(SListe.First());       
	            }
                else
                {
                    removeProfilFromSerie(SListe.First(), P);
                }
                SListe.RemoveAt(0);

            }

            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "deleteProfil";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", P.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        public Profil ProfilAusgeben(int ID)
        {
            Profil P = new Profil(ID);
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getProfilById";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                P.setBezeichnung(reader.GetString(0));
                P.setHoeheAbs(reader.GetDecimal(1));
                P.setTiefeAbs(reader.GetDecimal(2));
                P.setRahmenFenster(inttobool(reader.GetInt32(3)));
                P.setErstelltVon(getBenutzerByID(reader.GetInt32(4)));
                P.setErstelltWann(reader.GetDateTime(5));
                P.setFreigabeVon(getBenutzerByID(reader.GetInt32(6)));
                P.setFreigabeWann(reader.GetDateTime(7));
                P.setKommentar(reader.GetString(8));
                P.setStatus(getStatusByID(reader.GetInt32(9)));
                byte[] Layer = null;
                Layer = (byte[])reader[10];
                MemoryStream mstream = new MemoryStream();
                mstream.Write(Layer, 0, Layer.Length);
                DxfReader dxfread = new DxfReader(mstream);
                DxfModel Data = dxfread.Read();
                mstream.Flush();
                mstream.Close();
                P.setZeichnung(Data);
                P.setLetzterBenutzer(getBenutzerByID(reader.GetInt32(11)));
            }
            conn.Close();
            P.setVerwendungposition(listProfilEinbaulagen(P));
            P.setDichtung(listProfilDichtungen(P));
            P.setRestriktion(listProfilRestriktionen(P));
            P.setBeschichtungen(listProfilBeschichtungen(P));
            P.setWerkstoff(listProfilWerkstoff(P));
            P.setFuellmaterial(listProfilFuellmaterial(P));
            P.setBearbeitungen(listProfilBearbeitungen(P));
            P.setHersteller(listProfilHersteller(P));
            P.setSerie(listProfilSerien(P));
            return P;
        }

        public void ProfileEinchecken(List<Profil> Liste, Benutzer B)
        {
            int Status = new int();
            Status = 1;
            int CountA = Liste.Count;
            while (CountA != 0)
            {
                Profil Profil = new Profil(-1);
                Profil = Liste.First();
                SqlConnection conn = new SqlConnection(connString);
                SqlCommand command = conn.CreateCommand();
                command.CommandText = "ProfilStatusAendern";
                command.CommandType = System.Data.CommandType.StoredProcedure;
                command.Parameters.AddWithValue("@ID", Profil.getID());
                command.Parameters.AddWithValue("@UserID", B.getMitarbeiternummer());
                command.Parameters.AddWithValue("@Status", Status);
                conn.Open();
                SqlDataReader reader = command.ExecuteReader();
                conn.Close();
                CountA = CountA - 1; 
                Liste.RemoveAt(0);
            }
        }

        public Boolean ProfilStatusAendern(Profil P, Benutzer B)
        {
            Boolean b = new Boolean();
            b= false;
            if (ProfilStatusAbfragen(P).getStatus().getID() != 0 || ProfilStatusAbfragen(P).getLetzterBearbeiter().getMitarbeiternummer() == B.getMitarbeiternummer())
            {
                SqlConnection conn = new SqlConnection(connString);
                SqlCommand command = conn.CreateCommand();
                command.CommandText = "ProfilStatusAendern";
                command.CommandType = System.Data.CommandType.StoredProcedure;
                command.Parameters.AddWithValue("@ID", P.getID());
                command.Parameters.AddWithValue("@Status", P.getStatus().getID());
                command.Parameters.AddWithValue("@UserID", B.getMitarbeiternummer());
                conn.Open();
                SqlDataReader reader = command.ExecuteReader();
                conn.Close();
                b = true;
            }
            return b;
        }

        protected Profil ProfilStatusAbfragen(Profil P)
        {
            Profil P2 = new Profil(P.getID());
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getProfilStatus";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("ID", P2.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                P2.setStatus(getStatusByID(reader.GetInt32(0)));
                P2.setLetzterBenutzer(getBenutzerByID(reader.GetInt32(1)));
            }
            conn.Close();
            return P2;
        }

        protected List<Teil> TeileAusgeben(Profil P)
        {
            List<Teil> Liste = new List<Teil>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listTeileByProfil";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", P.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Teil T = new Teil(reader.GetInt32(0));
                T.setKundenbezeichnung(reader.GetString(1));
                Liste.Add(T);
            }
            conn.Close();
            return Liste;
        }

        public List<Teil> TeileAusgeben(Auftrag A, List<Bearbeitungen> Beli)
        {
            List<Teil> Zwichenliste = new List<Teil>();
            List<Teil> Ausgabe = new List<Teil>();
            while (Beli.Count() != 0)
            {
                Zwichenliste.AddRange(TeileAusgeben(A,Beli.First()));
                Beli.RemoveAt(0);
            }
            while (Zwichenliste.Count() != 0)
            {
                Ausgabe.Add(TeilAusgeben(Zwichenliste.First().getID()));
                Zwichenliste.RemoveAt(0);
            }
            return Ausgabe;
        }

        protected List<Teil> TeileAusgeben(Auftrag A, Bearbeitungen B)
        {
            List<Teil> Liste = new List<Teil>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listTeileByAuftragByBearbeitung";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Auftrag", A.getAuftragsnummer());
            command.Parameters.AddWithValue("@Bearbeitung", B.getBearbeitungsnummer());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Teil T = new Teil(-1);
                T.setID(reader.GetInt32(0));
                T.setKundenbezeichnung(reader.GetString(1));
                List<Bearbeitungen> BListe = new List<Bearbeitungen>();
                BListe.Add(B);
                T.setBearbeitungen(BListe);
                Liste.Add(T);
            }
            conn.Close();
            return Liste;
        }

        protected void TeilLoeschen(Teil T)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "TeilLoeschen";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", T.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
        }

        public List<Teil> TeileAusgebenSortiertNachMaßen(Auftrag Auftrag)
        {
            List<Teil> Liste = new List<Teil>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getTeilFromOrderByIDNachMaß";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", Auftrag.getAuftragsnummer());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Teil T = new Teil(reader.GetInt32(0),reader.GetInt32(2));
                T.setKundenbezeichnung(reader.GetString(1));
                T.setKundenserie(getKundenserie(reader.GetInt32(3)));
                T.setStatus(getStatusByID(reader.GetInt32(4)));
                Profil P = new Profil(T.getIDProfil());
                P.setHoeheAbs(reader.GetDecimal(5));
                P.setTiefeAbs(reader.GetDecimal(6));
                T.setProfil(P);
                Liste.Add(T);
            }
            conn.Close();
            return Liste;
        }

        public List<Teil> TeileAusgebenSortiertNachName(Auftrag Auftrag)
        {
            List<Teil> Liste = new List<Teil>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getTeilFromOrderByIDNachName";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", Auftrag.getAuftragsnummer());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Teil T = new Teil(reader.GetInt32(0), reader.GetInt32(2));
                T.setKundenbezeichnung(reader.GetString(1));
                T.setKundenserie(getKundenserie(reader.GetInt32(3)));
                T.setStatus(getStatusByID(reader.GetInt32(4)));
                Profil P = new Profil(T.getIDProfil());
                P.setHoeheAbs(reader.GetDecimal(5));
                P.setTiefeAbs(reader.GetDecimal(6));
                T.setProfil(P);
                Liste.Add(T);
            }
            conn.Close();
            return Liste;
        }

        public int TeilEintragen(Teil Teil)
        {
            if (Teil.getID() > 0)
            {
                TeilLoeschen(Teil);
            }
            //Teiltabelleneintrag
            int TeilID = new int();
            int ProfilID = Teil.getIDProfil();
            string Kommentar = Teil.getKommentar();
            int EV = Teil.getErstelltVon().getMitarbeiternummer();
            DateTime EW = Teil.getErstelltWann();
            int FV = Teil.getFreigabeVon().getMitarbeiternummer();
            DateTime FW = Teil.getFreigabeWann();
            int Status = Teil.getStatus().getID();
            int Serie = Teil.getKundenserie().getID();
            TeilID = createTeil(ProfilID, Kommentar, EV, EW, FV, FW, Status, Serie);

            //Einbaulagen Eintragen
            List<VerwendungPosition> EinbaulagenListe = new List<VerwendungPosition>(Teil.getVerwendungsposition());
            while (EinbaulagenListe.Count() != 0)
            {
                addTeilEinbaulage(TeilID, EinbaulagenListe.First().getID());
                EinbaulagenListe.RemoveAt(0);
            }

            //Dichtungen Eintragen
            List<Dichtung> DichtungListe = new List<Dichtung>(Teil.getDichtung());
            while (DichtungListe.Count() != 0)
            {
                addTeilDichtung(TeilID, DichtungListe.First().getID());
                DichtungListe.RemoveAt(0);
            }

            //Restriktionen Eintragen
            List<Restriktion> RestriktionenListe = new List<Restriktion>(Teil.getRestriktionen());
            while (RestriktionenListe.Count() != 0)
            {
                addTeilRestriktion(TeilID, RestriktionenListe.First().getID());
                RestriktionenListe.RemoveAt(0);
            }

            //Beschichtungen Eintragen
            List<Beschichtungen> Beschichtungsliste = new List<Beschichtungen>(Teil.getBeschichtungen());
            while (Beschichtungsliste.Count() != 0)
            {
                addTeilBeschichtung(TeilID, Beschichtungsliste.First().getID());
                Beschichtungsliste.RemoveAt(0);
            }

            //Werkstoffe Eintragen
            List<Werkstoff> Werkstoffliste = new List<Werkstoff>(Teil.getWerkstoff());
            while (Werkstoffliste.Count() != 0)
            {
                addTeilWerkstoff(TeilID, Werkstoffliste.First().getID());
                Werkstoffliste.RemoveAt(0);
            }

            //Fuellmaterilien Eintragen
            List<Fuellmaterial> Fuellmaterialliste = new List<Fuellmaterial>(Teil.getFuellmaterial());
            while (Fuellmaterialliste.Count() != 0)
            {
                addTeilFuellmaterial(TeilID, Fuellmaterialliste.First().getID());
                Fuellmaterialliste.RemoveAt(0);
            }

            //Bearbeitungen Eintragen
            List<Bearbeitungen> BearbeitungsListe = new List<Bearbeitungen>(Teil.getBearbeitungen());
            while (BearbeitungsListe.Count() != 0)
            {
                addTeilBearbeitung(TeilID, BearbeitungsListe.First().getID());
                BearbeitungsListe.RemoveAt(0);
            }
            return TeilID;
        }

        public Teil TeilAusgeben(int ID)
        {
            Teil T = new Teil(ID);
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getTeilByID";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                T.setIDProfil(reader.GetInt32(0));
                T.setKommentar(reader.GetString(1));
                T.setErstelltVon(getBenutzerByID(reader.GetInt32(2)));
                T.setErstelltWann(reader.GetDateTime(3));
                T.setFreigabeVon(getBenutzerByID(reader.GetInt32(4)));
                T.setFreigabeWann(reader.GetDateTime(5));
                T.setStatus(getStatusByID(reader.GetInt32(6)));
                T.setKundenserie(getKundenserie(reader.GetInt32(7)));
                byte[] Layer = null;
                Layer = (byte[])reader[8];
                MemoryStream mstream = new MemoryStream();
                mstream.Write(Layer, 0, Layer.Length);
                DxfReader dxfread = new DxfReader(mstream);
                DxfModel Data = dxfread.Read();
                mstream.Flush();
                mstream.Close();
                T.setZeichnung(Data);
                T.setKundenbezeichnung(reader.GetString(9));
            }
            conn.Close();
            T.setVerwendungposition(listTeilEinbaulagen(T));
            T.setDichtung(listTeilDichtungen(T));
            T.setRestriktionen(listTeilRestriktionen(T));
            T.setBeschichtungen(listTeilBeschichtungen(T));
            T.setWerkstoff(listTeilWerkstoff(T));
            T.setFuellmaterial(listTeilFuellmaterial(T));
            T.setBearbeitungen(listTeilBearbeitungen(T));
            return T;
        }

        public void AuftragEintragen(Auftrag A)
        {
            try
            {
                SqlConnection conn = new SqlConnection(connString);
                SqlCommand command = conn.CreateCommand();
                command.CommandText = "createAuftrag";
                command.CommandType = System.Data.CommandType.StoredProcedure;
                command.Parameters.AddWithValue("@ID", A.getAuftragsnummer());
                command.Parameters.AddWithValue("@Kunde", A.getKunde().getKundennummer());
                command.Parameters.AddWithValue("@Zustand", A.getZustand().getID());
                command.Parameters.AddWithValue("@Bearbeiter", A.getLetzterBearbeiter().getMitarbeiternummer());
                conn.Open();
                SqlDataReader reader = command.ExecuteReader();
                conn.Close();
            }
            catch (Exception)
            {
                SqlConnection conn = new SqlConnection(connString);
                SqlCommand command = conn.CreateCommand();
                command.CommandText = "changeAuftrag";
                command.CommandType = System.Data.CommandType.StoredProcedure;
                command.Parameters.AddWithValue("@ID", A.getAuftragsnummer());
                command.Parameters.AddWithValue("@Kunde", A.getKunde().getKundennummer());
                command.Parameters.AddWithValue("@Zustand", A.getZustand().getID());
                command.Parameters.AddWithValue("@Bearbeiter", A.getLetzterBearbeiter().getMitarbeiternummer());
                conn.Open();
                SqlDataReader reader = command.ExecuteReader();
                conn.Close();
            }
            
        }

        public void AuftragLoeschen(Auftrag A)
        {
            List<Teil> TListe = new List<Teil>();
            TListe = TeileAusgebenSortiertNachMaßen(A);
            int Ti = new int();
            Ti = TListe.Count();
            while (Ti != 0)
            {
                TeilLoeschen(TListe.First());
                TListe.RemoveAt(0);
                Ti = Ti - 1;
            }
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "deleteAuftrag";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", A.getAuftragsnummer());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        public Boolean AuftragStatusAendern(Auftrag A, Benutzer B)
        {
            Boolean b = new Boolean();
            b = false;
            if (AuftragStatusAbfragen(A).getZustand().getID() != 0 || AuftragStatusAbfragen(A).getLetzterBearbeiter().getMitarbeiternummer() == B.getMitarbeiternummer())
            {
                SqlConnection conn = new SqlConnection(connString);
                SqlCommand command = conn.CreateCommand();
                command.CommandText = "AuftragStatusAendern";
                command.CommandType = System.Data.CommandType.StoredProcedure;
                command.Parameters.AddWithValue("@Auftrag", A.getAuftragsnummer());
                command.Parameters.AddWithValue("@Benutzer", B.getMitarbeiternummer());
                command.Parameters.AddWithValue("@Zustand", A.getZustand().getID());
                conn.Open();
                SqlDataReader reader = command.ExecuteReader();
                conn.Close();
                b = true;
            }
            return b;
        }

        protected Auftrag AuftragStatusAbfragen(Auftrag A)
        {
            Auftrag A2 = new Auftrag(A.getAuftragsnummer());
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "AuftragStatusAbfragen";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", A.getAuftragsnummer());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Zustand Z = new Zustand(reader.GetInt32(0));
                Z.setZustand(reader.GetString(1));
                Benutzer B = new Benutzer(reader.GetInt32(2));
                B.setBenutzername(reader.GetString(3));
                B.setRolle(getRolle(reader.GetInt32(4)));
                A2.setZustand(Z);
                A2.setLetzterBearbeiter(B);
            }
            conn.Close();
            return A2;
        }

        

        protected int AnsprechpartnerEintragen(Ansprechpartner Partner)
        {
            int ID = new int();
            int Geschlecht = Partner.getGeschlecht().getID();
            string Vorname = Partner.getVorname();
            string Nachname = Partner.getNachname();
            string Titel = Partner.getTitel();
            string Fachbereich = Partner.getFachbereich();
            string Telefon1 = Partner.getTelefon1();
            string Telefon2 = Partner.getTelefon2();
            string Email = Partner.getEmail();
            string Fax = Partner.getFax();
            string Kommentar = Partner.getKommentar();
            ID = createAnsprechpartner(Geschlecht, Vorname, Nachname, Titel, Fachbereich, Telefon1, Telefon2, Email, Fax, Kommentar);

            //Sprache Eintragen
            List<Sprache> Sprachenliste = new List<Sprache>(Partner.getSprache());
            int CountS = Sprachenliste.Count;
            while (CountS != 0)
            {
                int SprachenID = new int();
                Sprache Sprache = Sprachenliste.First();
                SprachenID = Sprache.getID();
                //Sprache Verknüpfen
                addAnsprechpartnerSprache(ID, SprachenID);
                Sprachenliste.RemoveAt(0);
                CountS = CountS - 1;
            }
            return ID;
        }

        protected void AnsprechpartnerBearbeiten(Ansprechpartner Partner)
        {
            //Eintrag in Liste Ansprechpartner bearbeiten
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "changeAnsprechpartner";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", Partner.getID());
            command.Parameters.AddWithValue("@Geschlecht", Partner.getGeschlecht().getID());
            command.Parameters.AddWithValue("@Vorname", Partner.getVorname());
            command.Parameters.AddWithValue("@Nachname", Partner.getNachname());
            command.Parameters.AddWithValue("@Titel", Partner.getTitel());
            command.Parameters.AddWithValue("@Fachbereich", Partner.getFachbereich());
            command.Parameters.AddWithValue("@Telefon1", Partner.getTelefon1());
            command.Parameters.AddWithValue("@Telefon2", Partner.getTelefon2());
            command.Parameters.AddWithValue("@Email", Partner.getEmail());
            command.Parameters.AddWithValue("@Fax", Partner.getFax());
            command.Parameters.AddWithValue("@Kommentar", Partner.getKommentar());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();

            //Sprachen Löschen
            SqlConnection conn2 = new SqlConnection(connString);
            SqlCommand command2 = conn2.CreateCommand();
            command2.CommandText = "removeAnsprechpartnerSprache";
            command2.CommandType = System.Data.CommandType.StoredProcedure;
            command2.Parameters.AddWithValue("@ID", Partner.getID());
            conn2.Open();
            SqlDataReader reader2 = command2.ExecuteReader();
            conn2.Close();

            //Sprache Eintragen
            List<Sprache> Sprachenliste = new List<Sprache>(Partner.getSprache());
            int CountS = Sprachenliste.Count;
            while (CountS != 0)
            {
                int SprachenID = new int();
                Sprache Sprache = Sprachenliste.First();
                SprachenID = Sprache.getID();
                //Sprache Verknüpfen
                addAnsprechpartnerSprache(Partner.getID(), SprachenID);
                Sprachenliste.RemoveAt(0);
                CountS = CountS - 1;
            }
            
        }

        public void AnsprechpartnerLoeschen(Ansprechpartner Partner)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "deleteAnsprechpartner";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", Partner.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            conn.Close();
        }

        public Benutzer getBenutzerByID(int ID)
        {
            Benutzer Benutzer = new Benutzer(-1);
            Rolle Rolle = new Rolle();
            int RollenID = new int();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getBenutzerByID";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Param", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Benutzer.setMitarbeiternummer(reader.GetInt32(0));
                Benutzer.setBenutzername(reader.GetSqlString(1).ToString());
                RollenID = reader.GetInt32(2);
                Benutzer.setRolle(Rolle);
            }
            Rolle = getRolle(RollenID);
            Benutzer.setRolle(Rolle);
            conn.Close();
            return Benutzer;
        }

        public Benutzer getBenutzerByName(string Name)
        {
            Benutzer Benutzer = new Benutzer(-1);
            Rolle Rolle = new Rolle();
            int RollenID = new int();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getBenutzerByName";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@Param", Name);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Benutzer.setMitarbeiternummer(reader.GetInt32(0));
                Benutzer.setBenutzername(reader.GetSqlString(1).ToString());
                RollenID = reader.GetInt32(2);
                Benutzer.setRolle(Rolle);
            }
            Rolle = getRolle(RollenID);
            Benutzer.setRolle(Rolle);
            conn.Close();
            return Benutzer;
        }

        public void changeBenutzer(Benutzer alt, Benutzer neu)
        {
            int IDalt = alt.getMitarbeiternummer();
            int IDneu = neu.getMitarbeiternummer();
            string NameNeu = neu.getbenutzername();
            int RolleNeu = neu.getRolle().getid();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "ChangeBenuter";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@IDalt", IDalt);
            command.Parameters.AddWithValue("@IDneu", IDneu);
            command.Parameters.AddWithValue("@NameNeu", NameNeu);
            command.Parameters.AddWithValue("@RolleNeu", RolleNeu);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
        }

        protected Zustand getZustand(int ID)
        {
            Zustand Zustand = new Zustand(ID);
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getZustandByID";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Zustand.setZustand(reader.GetString(0));
            }
            conn.Close();
            return Zustand;
        }     

        protected Werkzeug getWerkzeugByID(int ID)
        {
            Werkzeug Tool = new Werkzeug();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getWerkzeugByID";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Tool.setID(ID);
                Tool.setWerkzeugart(reader.GetString(0));
                Tool.setWerkzeugmaße(reader.GetString(1));
            }
            conn.Close();
            return Tool;
        }

        public Bearbeitungen getBearbeitung(int ID)
        {
            Bearbeitungen Bearbeitung = new Bearbeitungen(-1);
            Werkzeug Werkzeug = new Werkzeug();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getBearbeitung";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                byte[] Layer = null;
                Layer = (byte[])reader[5];
                MemoryStream mstream = new MemoryStream();
                mstream.Write(Layer, 0, Layer.Length);
                DxfReader dxfread = new DxfReader(mstream);
                DxfModel Data = dxfread.Read();
                mstream.Flush();
                mstream.Close();
                Bearbeitung.setID(reader.GetInt32(0));
                Bearbeitung.setBearbeitungsnummer(reader.GetInt32(1));
                Bearbeitung.setBearbeitungsname(reader.GetSqlString(2).ToString());
                Bearbeitung.setBearbeitungswinkel(reader.GetSqlString(3).ToString());
                Bearbeitung.setKommentar(reader.GetSqlString(4).ToString());
                Bearbeitung.setLayer(Data);
                Werkzeug = getWerkzeugByID(reader.GetInt32(6));
                Bearbeitung.setWerzeug(Werkzeug);
            }
            conn.Close();
            return Bearbeitung;
        }

        public List<Bearbeitungen> getBearbeitungen(Auftrag A)
        {
            List<Bearbeitungen> Liste = new List<Bearbeitungen>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getBearbeitungenByAuftrag";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", A.getAuftragsnummer());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            byte[] Layer = null;
            while (reader.Read())
            {
                Bearbeitungen Bearbeitung = new Bearbeitungen(-1);
                Werkzeug Werkzeug = new Werkzeug();
                Layer = (byte[])reader[5];
                MemoryStream mstream = new MemoryStream();
                mstream.Write(Layer, 0, Layer.Length);
                DxfReader dxfread = new DxfReader(mstream);
                DxfModel bytestream = dxfread.Read();
                mstream.Flush();
                mstream.Close();
                Bearbeitung.setID(reader.GetInt32(0));
                Bearbeitung.setBearbeitungsnummer(reader.GetInt32(1));
                Bearbeitung.setBearbeitungsname(reader.GetString(2));
                Bearbeitung.setBearbeitungswinkel(reader.GetString(3));
                Bearbeitung.setKommentar(reader.GetString(4));
                Bearbeitung.setLayer(bytestream);
                Werkzeug = getWerkzeugByID(reader.GetInt32(6));
                Bearbeitung.setWerzeug(Werkzeug);
                if (Liste.Count() == 0)
                {
                    Liste.Add(Bearbeitung);
                }
                else
                {
                    if (Bearbeitung.getBearbeitungsnummer() != Liste.Last().getBearbeitungsnummer())
                    {
                        Liste.Add(Bearbeitung);
                    }  
                }
                
            }
            conn.Close();
            return Liste;
        }

        public Kunde getKundeByID(int ID)
        {
            Kunde Kunde = new Kunde(ID);
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getKundeByID";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Kunde.setName(reader.GetString(0));
            }
            conn.Close();
            Kunde.setAnsprechpartner(getAnsprechparterFromKundeByID(ID));
            return Kunde;
        }

        protected List<Sprache> getSprachenByAnsprechpartnerID(int ID)
        {
            List<Sprache> Liste = new List<Sprache>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getSprachenByAnsprechpartnerID";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Sprache Sprache = new Sprache();
                Sprache.setID(reader.GetInt32(0));
                Sprache.setSprache(reader.GetString(1));
                Liste.Add(Sprache);
            }
            conn.Close();
            return Liste;
        }

        public List<Ansprechpartner> getAnsprechparterFromKundeByID(int ID)
        {
            List<Ansprechpartner> Liste = new List<Ansprechpartner>();
            Ansprechpartner Ansprechpartner = new Ansprechpartner(-1);
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAnsprechpartnerFromKunde";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Ansprechpartner = getAnsprechpartnerByID(reader.GetInt32(0));
                Liste.Add(Ansprechpartner);
            }
            conn.Close();
            return Liste;
        }

        protected Ansprechpartner getAnsprechpartnerByID(int ID)
        {
            Ansprechpartner Ansprechpartner = new Ansprechpartner(-1);
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAnsprechpartnerByID";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", ID);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Ansprechpartner.setID(ID);
                Ansprechpartner.setGeschlecht(getGeschlechtByID(reader.GetInt32(0)));
                Ansprechpartner.setVorname(reader.GetString(1));
                Ansprechpartner.setNachname(reader.GetString(2));
                Ansprechpartner.setTitel(reader.GetString(3));
                Ansprechpartner.setFachbereich(reader.GetString(4));
                Ansprechpartner.setTelefon1(reader.GetString(5));
                Ansprechpartner.setTelefon2(reader.GetString(6));
                Ansprechpartner.setEmail(reader.GetString(7));
                Ansprechpartner.setFax(reader.GetString(8));
                Ansprechpartner.setKommentar(reader.GetString(9));
            }
            conn.Close();
            Ansprechpartner.setSprache(getSprachenByAnsprechpartnerID(ID));
            return Ansprechpartner;
        }

        public List<Restriktion> getRestriktionen(Auftrag A)
        {
            List<Restriktion> Liste = new List<Restriktion>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getTeilRestriktionenByAuftrag";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", A.getAuftragsnummer());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Restriktion R = new Restriktion(reader.GetInt32(0));
                R.setArtikelnummer(reader.GetInt32(1));
                R.setRestriktion(reader.GetString(2));
                if (Liste.Count() != 0)
                {
                    if (R.getArtikelnummer() != Liste.Last().getArtikelnummer() || R.getRestriktion() != Liste.Last().getRestriktion() )
                    {
                        Liste.Add(R);
                    }
                }
                else
                {
                    Liste.Add(R);
                }
            }
            conn.Close();
            return Liste;
        }
        
        public Auftrag getAuftrag(int Auftragsnummer)
        {
            Auftrag Auftrag = new Auftrag(Auftragsnummer);
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAuftragByAuftragsID";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", Auftragsnummer);
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Auftrag.setKunde(getKundeByID(reader.GetInt32(0)));
                Auftrag.setZustand(getZustand(reader.GetInt32(1)));
                Auftrag.setLetzterBearbeiter(getBenutzerByID(reader.GetInt32(2)));
            }
            Auftrag.setTeil(TeileAusgebenSortiertNachName(Auftrag));
            conn.Close();
            return Auftrag;

        }

        public List<Auftrag> getAuftraege(Zustand Z)
        {
            List<Auftrag> Liste = new List<Auftrag>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAuftraegeByZustand";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", Z.getID());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Auftrag A = new Auftrag(reader.GetInt32(0));
                A.setZustand(Z);
                A.setKunde(getKundeByID(reader.GetInt32(1)));
                Liste.Add(A);
            }
            conn.Close();
            return Liste;
        }

        public List<Auftrag> getAuftraege(Kunde K)
        {
            List<Auftrag> Liste = new List<Auftrag>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAuftraegeByKunde";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            command.Parameters.AddWithValue("@ID", K.getKundennummer());
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Auftrag A = new Auftrag(reader.GetInt32(0));
                A.setZustand(getZustand(reader.GetInt32(1)));
                A.setLetzterBearbeiter(getBenutzerByID(reader.GetInt32(2)));
                A.setKunde(K);
                Liste.Add(A);
            }
            conn.Close();
            return Liste;
        }

        public List<Zustand> listZustaende()
        {
            List<Zustand> Liste = new List<Zustand>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listZustaende";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Zustand Z = new Zustand(reader.GetInt32(0));
                Z.setZustand(reader.GetString(1));
                Liste.Add(Z);
            }
            conn.Close();
            return Liste;
        }

        public List<Serie> listHerstellerSerien()
        {
            List<Serie> Liste = new List<Serie>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "listHerstellerSerien";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Serie S = new Serie(reader.GetInt32(0));
                S.setSerie(reader.GetString(1));
                if (Liste.Count() == 0)
                {
                Liste.Add(S);    
                }
                else
                {
                    if (Liste.Last().getSerie() != S.getSerie())
                    {
                        Liste.Add(S);
                    }
                }
                
            }
            conn.Close();
            return Liste;
        }

        public List<Serie> listAlleProfilSerien()
        {
            List<Serie> Liste = new List<Serie>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "ListAlleProfilSerien";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Serie S = new Serie(reader.GetInt32(0));
                S.setSerie(reader.GetString(1));
                Liste.Add(S);
            }
            conn.Close();
            return Liste;
        }

        public List<Beschichtungen> listAlleBeschichtungen()
        {
            List<Beschichtungen> Liste = new List<Beschichtungen>();
            SqlConnection conn = new SqlConnection(connString);
            SqlCommand command = conn.CreateCommand();
            command.CommandText = "getAllBeschichtungen";
            command.CommandType = System.Data.CommandType.StoredProcedure;
            conn.Open();
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Beschichtungen B = new Beschichtungen(reader.GetInt32(0));
                B.setBeschichtungen(reader.GetString(1));
                Liste.Add(B);
            }
            conn.Close();
            return Liste;
        }


        internal bool VerbindungPruefen()
        {
            SqlConnection conn = new SqlConnection(connString);
            bool stopTrying = false;
            DateTime time = DateTime.Now;
            while (!stopTrying)
            {
                try
                {
                    Ping s = new Ping();
                    PingReply reply = s.Send(Settings.Default.Server);
                    if (reply.Status == IPStatus.Success)
                    {
                       

                    }
                    else
                    {
                        return false;

                    }

                    conn.Open();
                    conn.Close();
                    return true;
                }
                catch (Exception)
                {
                    if (DateTime.Now.Subtract(time).Milliseconds > 10000)
                    {
                        stopTrying = true;
                        return false;
                    }
                    else
                    {
                        return false;
                    }

                    
                }
            }
            return false;
           
        }
    }


}
